const db = uniCloud.databaseForJQL()
import store from "../store"

/**
 * 处理好友关系（添加/删除好友）
 * @param {Object} targetUser - 目标用户完整信息
 * @param {String} action - 操作类型：'add'添加好友，'del'删除好友
 * @returns {Promise<Object>} - 操作结果 { success: Boolean, message: String, friends: Array }
 */
export async function handleFriendRelation(targetUser, action) {
  // 解构目标用户信息，默认值避免字段缺失
  const {
    userId: targetUserId,
    nicName = '未知用户',
    nicPic = '/static/images/default-avatar.png',
    userTel = '',
    signature = '暂无签名',
    isStick = false, // 是否置顶
    customize_name = '', // 备注名（优先显示）
    customize_pic = '' // 备注头像（优先显示）
  } = targetUser || {}

  try {
    // 1. 获取当前用户信息，校验合法性
    const currentUser = store.getters['msg/getUserInfo']
    if (!currentUser || !currentUser.userId) {
      return {
        success: false,
        message: '当前用户信息不存在'
      }
    }
    const currentUserId = currentUser.userId

    // 2. 基础校验：目标用户ID必填 + 不能操作自己
    if (!targetUserId) {
      return { success: false, message: '目标用户ID不能为空' }
    }
    if (targetUserId === currentUserId) {
      return {
        success: false,
        message: action === 'add' ? '不能添加自己为好友' : '不能删除自己'
      }
    }

    // 3. 初始化好友列表（确保是数组，避免后续操作报错）
    let friends = Array.isArray(currentUser.friends) 
      ? [...currentUser.friends] 
      : []

    // 4. 定义"好友对象结构"（统一格式，包含基础信息和备注信息）
    const friendItem = {
      userId: targetUserId, // 目标用户唯一ID（核心标识）
      nicName, // 原昵称
      nicPic, // 原头像
      userTel, // 联系方式
      signature, // 个性签名
      isStick, // 置顶状态
      customize_name, // 备注名（前端显示时优先用这个）
      customize_pic, // 备注头像（前端显示时优先用这个）
      addTime: new Date().getTime() // 添加时间（用于排序）
    }

    // -------------------------- 添加好友逻辑 --------------------------
    if (action === 'add') {
      // 检查是否已为好友（通过userId判断，避免重复添加）
      const isAlreadyFriend = friends.some(item => item.userId === targetUserId)
      if (isAlreadyFriend) {
        return { success: false, message: '该用户已是您的好友' }
      }

      // 添加到当前用户好友列表
      friends.push(friendItem)

      // 双向添加：将当前用户添加到目标用户的好友列表（可选，根据需求启用）
      await addFriendToTargetUser(currentUser, targetUserId)
    }

    // -------------------------- 删除好友逻辑 --------------------------
    if (action === 'del') {
      // 检查是否为好友（通过userId判断）
      const isFriend = friends.some(item => item.userId === targetUserId)
      if (!isFriend) {
        return { success: false, message: '该用户不是您的好友' }
      }

      // 从当前用户好友列表移除（过滤掉目标用户）
      friends = friends.filter(item => item.userId !== targetUserId)

      // 双向删除：从目标用户好友列表移除当前用户
      await removeFriendFromTargetUser(currentUserId, targetUserId)
    }

    // 5. 更新Vuex状态：同步最新好友列表
    store.commit('msg/SET_user', {
      ...currentUser,
      friends: [...friends] // 深拷贝避免引用问题
    })

    // 6. 同步更新数据库：确保数据持久化
    const dbResult = await db.collection('linli-user')
      .where({ userId: currentUserId })
      .update({ friends: [...friends] })

    // 校验数据库更新结果
    if (dbResult.updated === 0) {
      throw new Error('数据库更新失败，未找到当前用户或数据无变化')
    }

    // 操作成功：返回结果
    return {
      success: true,
      message: action === 'add' ? '添加好友成功' : '删除好友成功',
      friends: [...friends] // 返回最新好友列表，方便前端渲染
    }

  } catch (error) {
    console.error(`好友操作（${action}）失败:`, error)
    // 数据库更新失败时回滚Vuex状态，避免数据不一致
    store.commit('msg/SET_user', store.getters['msg/getUserInfo'])
    return {
      success: false,
      message: action === 'add' ? '添加好友失败，请重试' : '删除好友失败，请重试',
      friends: currentUser?.friends || []
    }
  }
}

/**
 * 辅助函数：将当前用户添加到目标用户的好友列表（双向添加）
 * @param {Object} currentUser - 当前用户完整信息
 * @param {String} targetUserId - 目标用户ID
 */
async function addFriendToTargetUser(currentUser, targetUserId) {
  try {
    // 1. 查询目标用户信息
    const targetRes = await db.collection('linli-user')
      .where({ userId: targetUserId })
      .get()

    if (targetRes.data.length === 0) {
      throw new Error('目标用户不存在，无法完成双向添加')
    }

    const targetUser = targetRes.data[0]
    // 2. 初始化目标用户的好友列表
    let targetFriends = Array.isArray(targetUser.friends) 
      ? [...targetUser.friends] 
      : []

    // 3. 检查当前用户是否已在目标用户好友列表中
    const isAlreadyInTarget = targetFriends.some(
      item => item.userId === currentUser.userId
    )
    if (isAlreadyInTarget) return // 已存在则无需重复添加

    // 4. 构造目标用户列表中的"当前用户对象"（仅保留必要信息）
    const currentUserForTarget = {
      userId: currentUser.userId,
      nicName: currentUser.nicName || '未知用户',
      nicPic: currentUser.nicPic || '/static/images/default-avatar.png',
      signature: currentUser.signature || '暂无签名',
      isStick: false,
      customize_name: '', // 目标用户的备注名由其自行设置
      customize_pic: '',
      addTime: new Date().getTime()
    }

    // 5. 更新目标用户的好友列表并同步到数据库
    targetFriends.push(currentUserForTarget)
    await db.collection('linli-user')
      .where({ userId: targetUserId })
      .update({ friends: targetFriends })

  } catch (error) {
    console.error('双向添加好友失败:', error)
    // 双向添加失败不阻断主流程（避免因目标用户问题导致当前用户操作失败）
    throw new Error(`双向添加失败：${error.message}`)
  }
}

/**
 * 辅助函数：从目标用户好友列表移除当前用户（双向删除）
 * @param {String} currentUserId - 当前用户ID
 * @param {String} targetUserId - 目标用户ID
 */
async function removeFriendFromTargetUser(currentUserId, targetUserId) {
  try {
    // 1. 查询目标用户信息
    const targetRes = await db.collection('linli-user')
      .where({ userId: targetUserId })
      .get()

    if (targetRes.data.length === 0) return // 目标用户不存在，无需处理

    const targetUser = targetRes.data[0]
    // 2. 初始化目标用户的好友列表
    let targetFriends = Array.isArray(targetUser.friends) 
      ? [...targetUser.friends] 
      : []

    // 3. 检查当前用户是否在目标用户好友列表中
    const isInTarget = targetFriends.some(item => item.userId === currentUserId)
    if (!isInTarget) return // 不在列表中，无需处理

    // 4. 移除当前用户并同步到数据库
    targetFriends = targetFriends.filter(item => item.userId !== currentUserId)
    await db.collection('linli-user')
      .where({ userId: targetUserId })
      .update({ friends: targetFriends })

  } catch (error) {
    console.error('双向删除好友失败:', error)
    throw new Error(`双向删除失败：${error.message}`)
  }
}